package cn.edu.qzuie.artist.module.td.service.activity;

import cn.edu.qzuie.artist.module.td.controller.admin.publishactivity.vo.PublishActivitySaveReqVO;
import cn.edu.qzuie.artist.module.td.dal.dataobject.participateactivitiy.ParticipateActivitiyDO;
import cn.edu.qzuie.artist.module.td.dal.mysql.participateactivitiy.ParticipateActivitiyMapper;
import cn.edu.qzuie.artist.module.td.dal.mysql.publishactivity.PublishActivityMapper;
import cn.edu.qzuie.artist.module.td.service.publishactivity.PublishActivityService;
import org.springframework.boot.autoconfigure.security.oauth2.resource.OAuth2ResourceServerProperties;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import cn.edu.qzuie.artist.module.td.controller.admin.activity.vo.*;
import cn.edu.qzuie.artist.module.td.dal.dataobject.activity.ActivityDO;
import cn.edu.qzuie.artist.framework.common.pojo.PageResult;
import cn.edu.qzuie.artist.framework.common.pojo.PageParam;
import cn.edu.qzuie.artist.framework.common.util.object.BeanUtils;

import cn.edu.qzuie.artist.module.td.dal.mysql.activity.ActivityMapper;

import javax.annotation.Resource;

import static cn.edu.qzuie.artist.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.edu.qzuie.artist.module.td.enums.ErrorCodeConstants.*;

/**
 * 活动 Service 实现类
 *
 * @author 泉信管理员
 */
@Service
@Validated
public class ActivityServiceImpl implements ActivityService {

    @Resource
    private ActivityMapper activityMapper;
    @Resource
    private ParticipateActivitiyMapper participateActivitiyMapper;
    @Resource
    private PublishActivityService publishActivityService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createActivity(ActivitySaveReqVO createReqVO) {

        // 获取当前登录用户信息
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        // 获取当前登录用户的用户名
        String username = authentication.getName();
        // 首先获取 id
        // 通过第一个逗号（,）分割字符串，得到形如 "LoginUser(id=1" 的子串
        // 然后通过等号（=）进一步分割这个子串，取第二个元素即为 id 的值
        String ids = username.split(",")[0].split("=")[1];
        // 获取 nickname
        // 使用 "info=" 来分割字符串，获取其后的部分，即 "{nickname=泉信管理员, deptId=103}"
        String infoPart = username.split("info=")[1];
        // 在 infoPart 中，我们首先找到 "nickname=" 开始的位置，然后加上 "nickname=".length() (9个字符) 得到 nickname 值开始的位置
        // 然后找到 ", deptId" 开始的位置，这将是 nickname 值结束的位置
        // 使用 substring 方法根据这两个位置提取 nickname 的值
        String nickname = infoPart.substring(infoPart.indexOf("nickname=") + 9, infoPart.indexOf(", deptId"));

        // 插入
        ActivityDO activity = BeanUtils.toBean(createReqVO, ActivityDO.class);
        activityMapper.insert(activity);


        PublishActivitySaveReqVO saveReqVO = new PublishActivitySaveReqVO();
        // 1.将获取到的当前登录用户的id和活动id 插入到td_publish_activity中
        saveReqVO.setActivityId(activity.getId()); // 设置活动id
        Long userId = Long.parseLong(ids);
        saveReqVO.setUserId(userId); //设置用户id
        saveReqVO.setUserType(false); //状态
        saveReqVO.setNickName(nickname); //设置发布者的名称
        saveReqVO.setActivityName(activity.getActivityName()); //设置活动名称
        // 2.插入到td_publish_activity中
        publishActivityService.createPublishActivity(saveReqVO);
        // 返回
        return activity.getId();
    }

    @Override
    public void updateActivity(ActivitySaveReqVO updateReqVO) {
        // 校验存在
        validateActivityExists(updateReqVO.getId());
        // 更新
        ActivityDO updateObj = BeanUtils.toBean(updateReqVO, ActivityDO.class);
        activityMapper.updateById(updateObj);
    }

    @Override
    public void deleteActivity(Long id) {
        // 校验存在
        validateActivityExists(id);
        // 删除
        activityMapper.deleteById(id);
    }

    private void validateActivityExists(Long id) {
        if (activityMapper.selectById(id) == null) {
            throw exception(ACTIVITY_NOT_EXISTS);
        }
    }

    @Override
    public ActivityDO getActivity(Long id) {
        return activityMapper.selectById(id);
    }

    @Override
    public PageResult<ActivityDO> getActivityPage(ActivityPageReqVO pageReqVO) {
        // 动态更新获得状态 1：开始，2：暂停，3：结束
        // 1.先查询表中的结束时间判断是否结束
//        List<ActivityDO> activityDOList = activityMapper.selectList();
//
//        for (ActivityDO activityDO : activityDOList) {
//            //如果是暂停状态，跳出循环不做任何操作
//            if(activityDO.getActivityState()==2){
//                break;
//            }else{
//                Long activityId = activityDO.getId();
//                // 判断参与人数是否超过最大人数(避免新添加的活动人数是空的而抛出异常)
//                Integer participateNumber = participateActivitiyMapper.selectParticipateNumber(activityId); // 获取参与人数
//                if (participateNumber==null){
//                    break;
//                }
//                Integer maxParticipants = activityDO.getMaxNumber(); //最大人数
//                // 1.1 如果结束时间小于当前时间，则修改状态为结束
//                if (activityDO.getEndTime().isBefore(LocalDateTime.now())) {
//                    activityDO.setActivityState(3);
//                    // 更新
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }else if (activityDO.getEndTime().isAfter(LocalDateTime.now())){
//                    activityDO.setActivityState(1);
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }
//                if(participateNumber>=maxParticipants && maxParticipants!=0){
//                    activityDO.setActivityState(4);
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }
//            }
//        }
        //多表查询
        //1.查询
        return activityMapper.selectPage(pageReqVO);
    }

    /**
     * 多表查询
     * @param id
     * @return
     */
    @Override
    public ActivityRespVO getActivitys(Long id) {

        //先查询td_activity表中的数据
        ActivityDO activityDO = activityMapper.selectById(id);
        //通过活动id查询td_participate_activitiy表中参加获得的人数
        Integer participateNumber = participateActivitiyMapper.selectParticipateNumber(id);
        // DO 转 VO
        return convertToVO(activityDO,participateNumber);
    }

    // DO转VO
    private ActivitysRespVO convertToVO(ActivityDO activityDO, Integer participateNumber){

        ActivitysRespVO activitysRespVO = new ActivitysRespVO();
        BeanUtils.copyProperties(activityDO, activitysRespVO);
        activitysRespVO.setParticipantsNumber(participateNumber);
        return activitysRespVO;
    }

    /**
     * 多表分页查询
     * @param pageReqVO
     * @return
     */
    @Override
    public PageResult<ActivityPagesRespVO> getActivityPageWithName(ActivityPageReqVO pageReqVO) {
        // 动态更新获得状态 1：开始，2：暂停，3：结束
        // 1.先查询表中的结束时间判断是否结束
        // TODO 待优化，到时候会做一个定时任务,定时查询
//        List<ActivityDO> activityDOList = activityMapper.selectList();
//
//        for (ActivityDO activityDO : activityDOList) {
//            //如果是暂停状态，跳出循环不做任何操作
//            if(activityDO.getActivityState()==2){
//                break;
//            }else{
//
//                Integer maxParticipants = activityDO.getMaxNumber(); //最大人数
//                // 1.1 如果结束时间小于当前时间，则修改状态为结束
//                if (activityDO.getEndTime().isBefore(LocalDateTime.now())) {
//                    activityDO.setActivityState(3);
//                    // 更新
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }else if (activityDO.getStartTime().isAfter(LocalDateTime.now())){
//                    // 1.2 如果开始时间大于当前时间，则修改状态为未开始
//                    activityDO.setActivityState(5);
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }else{
//                    // 1.3 如果结束时间大于当前时间，则修改状态为开始
//                    activityDO.setActivityState(1);
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }
//                Long activityId = activityDO.getId();
//                // 判断参与人数是否超过最大人数(避免新添加的活动人数是空的而抛出异常)
//                Integer participateNumber = participateActivitiyMapper.selectParticipateNumber(activityId); // 获取参与人数
//                if (participateNumber==null){
//                    break;
//                }
//                if(participateNumber>=maxParticipants && maxParticipants!=0){
//                    // 1.4 如果参与人数大于最大人数，则修改状态为结束
//                    activityDO.setActivityState(4);
//                    activityMapper.updateBatchById(activityDO.getActivityState(),activityDO.getId());
//                }
//
//            }
//        }

        ActivityPageReqVO reqVO = new ActivityPageReqVO();
        BeanUtils.copyProperties(pageReqVO,reqVO); //对象属性拷贝
        return activityMapper.selectJoinPages(pageReqVO, reqVO);
    }

    /**
     * 更新活动状态
     * @param activityState
     * @param id
     */
    @Override
    public void updateActivityState(Integer activityState, Long id) {
        activityMapper.updateBatchById(activityState,id);
    }

}